// 计算绘制出来的军标图形的图案宽高
export const getDrawSize = (pointArr) => {
    if (pointArr.length < 2) return
    const w = (Math.abs(pointArr[1][0] - pointArr[0][0]))
    const h = (Math.abs(pointArr[1][1] - pointArr[0][1]))
    return { width: w, height: h }
}

// 计算缩放因子
export const getScaleFactor = (drawSize, svg) => {
    let { width, height } = svg.getBBox()
    if (width === 0 && svg.getAttribute('width')) {
        width = parseInt(svg.getAttribute('width'), 10) // 十进制获取元素的宽
    }
    if (height === 0 && svg.getAttribute('height')) {
        height = parseInt(svg.getAttribute('height'), 10)
    }
    const scaleX = drawSize.width / width
    const scaleY = drawSize.height / height
    // 返回一个比较大的比率因子
    return scaleX > scaleY ? scaleX : scaleY
}

// 获取旋转角度
export const getRotateFactor = (pointArr) => {
    if (pointArr.length < 2) return 0
    const x1 = pointArr[0][0] // .x
    const y1 = pointArr[0][1] // .y
    const x2 = pointArr[1][0] // .x
    const y2 = pointArr[1][1] // .y
    const rad = Math.atan2((y2 - y1), (x2 - x1)) + Math.PI / 2
    return rad
}

/* Method： calculateCoords(svg) {参数是记录svg数据的元素div；获取绘制范围的左上角坐标}
    * 解析SVG信息，将SVG信息解析成 屏幕坐标点信息 返回
    * 参数：iPath ：SVG格式的信息
    * 返回：组成svg的点信息（）
    */
export const calculateCoords = (cp, svg, scale = 1, cPoint) => {
    const x = cp[0]
    const y = cp[1]
    // 尝试两种方法来获取SVG元素的宽度/高度值,在地图上返回合理的x/y坐标。
    let { width, height } = svg.getBBox() // viewBox="0 0 200 200">
    if (width === 0 && svg.getAttribute('width')) {
        width = parseInt(svg.getAttribute('width'), 10) // 十进制获取元素的宽
    }
    if (height === 0 && svg.getAttribute('height')) {
        height = parseInt(svg.getAttribute('height'), 10)
    }
    switch (cPoint) {
        case 'CP':
            return {
                x: x - (width * scale / 2),
                y: y - (height * scale / 2)
            }
        // break
        case 'TL':
            return {
                x: x,
                y: y
            }
        // break
        case 'TM':
            return {
                x: x - (width * scale / 2),
                y: y
            }
        // break
        case 'TR':
            return {
                x: x - (width * scale),
                y: y
            }
        // break
        case 'LM':
            return {
                x: x,
                y: y - (height * scale / 2)
            }
        // break
        case 'RM':
            return {
                x: x - (width * scale),
                y: y - (height * scale / 2)
            }
        // break
        case 'BL':
            return {
                x: x,
                y: y - (height * scale)
            }
        // break
        case 'BM':
            return {
                x: x - (width * scale / 2),
                y: y - (height * scale)
            }
        // break
        case 'BR':
            return {
                x: x - (width * scale),
                y: y - (height * scale)
            }
        // break
        default:
            return {
                x: x - (width * scale / 2),
                y: y - (height * scale / 2)
            }
    }
}

/*  Method：setUnit
  * 返回根据地理坐标系获取的大小（宽高）
  * 参数 pointArr：绘制的控制点, basePoint： 中心点位置。 unitSize默认大小 = 1000米) 在地图上默认范围尺寸
  * 根据中心点（原-屏幕坐标）转地理坐标，加绘制地理尺寸后，转屏幕坐标并计算屏幕上长宽尺寸
  */
export const getUnitSize = (pointArr, basePoint, unitSize = [1000, 1000]) => {
    let centerPoint = window.map.getCoordinateFromPixel(pointArr[0])
    const sRCS = window.map.getView().getProjection().getCode()
    let lt // 左上
    let rb // 右下
    let screenlt // 左上屏幕坐标
    let screenrb // 右下屏幕坐标
    if (sRCS !== 'EPSG:3857') {
        centerPoint = olProj.transform(centerPoint, sRCS, 'EPSG:3857') // 将坐标数据转换成'EPSG:3857'
        lt = [centerPoint[0] - unitSize[0], centerPoint[1] - unitSize[1]]
        rb = [centerPoint[0] + unitSize[0], centerPoint[1] + unitSize[1]]
        lt = olProj.transform(lt, 'EPSG:3857', sRCS)
        rb = olProj.transform(rb, 'EPSG:3857', sRCS)
        screenlt = window.map.getPixelFromCoordinate(lt)
        screenrb = window.map.getPixelFromCoordinate(rb)
    } else {
        // 计算左上，右下坐标点，并且在最后转换成屏幕坐标
        lt = [centerPoint[0] - unitSize[0], centerPoint[1] - unitSize[1]]
        rb = [centerPoint[0] + unitSize[0], centerPoint[1] + unitSize[1]]
        screenlt = window.map.getPixelFromCoordinate(lt)
        screenrb = window.map.getPixelFromCoordinate(rb)
    }
    const w = (Math.abs(screenlt[0] - screenrb[0]))
    const h = (Math.abs(screenlt[1] - screenrb[1]))
    return { width: w, height: h }
}

// 实现类似生成器; 创建一个数字数组，从开始到结束（但不包括结束）
const range = (start, end) => {
    return new Array(end - start).fill(start).map((el, i) => start + i)
}

/* Method：groupStyle
 * 组样式信息补全；如果军标是由组构成的，其成员样式将保存在组<g>标签中；需要写入组中每个元素
 * 参数：tagData：组中的绘制元素，gStyle分组样式
 * 注意：只将信息补全，不替换用户设置颜色；颜色后续更改
 */
const groupStyle = (tagData, gStyle) => {
    // 设置填充色
    if (!tagData.getAttribute('fill')) {
        if (gStyle) {
            if (gStyle.fill === 'none') {
                tagData.setAttribute('fill', 'none')
            } else {
                tagData.setAttribute('fill', gStyle.fill)
            }
        }
    }
    // 设置边色
    if (!tagData.getAttribute('stroke')) {
        if (gStyle) {
            tagData.setAttribute('stroke', gStyle.stroke)
        }
    }
    // 设置边宽
    if (!tagData.getAttribute('stroke-width')) {
        if (gStyle) {
            tagData.setAttribute('stroke-width', gStyle['stroke-width'])
        }
    }
}

/* Method： pathToCoords
  * 将路径转变成坐标点
  * 参数：path路径 scale缩放因子 numPoints分段数量, translateX左上角坐标, translateY左上角坐标, cp中心点, rotate旋转弧度
  * 返回：组成svg的点信息（）
  */
export const pathToCoords = (path, scale, numPoints, translateX, translateY, cp, rotate = 0, callback, style) => {
    const length = path.getTotalLength() // 获取路径总长度
    // 创建一个指定长度的数组 getRange (numPoints圆和椭圆 16)
    const getRange = range(0, numPoints + 1) // 加一是为了获取到最有一个位置[0,5+1]-> i/numPoints=1
    // coords
    let coords = null
    if (rotate !== 0) {
        coords = getRange.map(function (i) {
            // 取路径上的点坐标（屏幕坐标）
            const point = path.getPointAtLength(length * i / numPoints)
            // 首先将坐标移动到原点（当前点+左上角位置）
            const x = (point.x * scale + translateX) - cp[0] // cp.x
            const y = (point.y * scale + translateY) - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else {
        coords = getRange.map(function (i) {
            const point = path.getPointAtLength(length * i / numPoints)
            return [point.x * scale + translateX, point.y * scale + translateY]
        })
    }
    groupStyle(path, style) // 组样式补全
    callback({ path, coords })
}

/* Method： circleToCoords
 * 将圆形转变成坐标点
 * 参数：circle：svg圆数据；scale：缩放, numPoints：点数, translateX, translateY：左上点位置
 * 返回：组成svg的点信息（）
 */
export const circleToCoords = (circle, scale, numPoints, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 弧度 = 2*PI/360*角度
    const aRadian = 2 * Math.PI / numPoints // 角的弧度
    const cx = parseFloat(circle.getAttribute('cx')) * scale
    const cy = parseFloat(circle.getAttribute('cy')) * scale
    const r = parseFloat(circle.getAttribute('r')) * scale
    const getRange = range(0, numPoints + 1) // 多加一个点首末坐标相同封口
    let x1 = 0.0// 圆上坐标点x
    let y1 = 0.0// 圆上坐标点y
    let coords = null
    // 根据获取的圆心和半径，计算圆上的坐标点(已经计算缩放)
    const points = getRange.map(function (i) {
        x1 = cx + r * Math.cos(aRadian * i)
        y1 = cy + r * Math.sin(aRadian * i)
        return [x1 + translateX, y1 + translateY]
    })
    points[numPoints] = points[0] // 圆形周长上点封闭
    // 旋转计算
    if (rotate !== 0) {
        coords = points.map(function (p) {
            const x = p[0] - cp[0] // cp.x
            const y = p[1] - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else {
        coords = points
    }
    if (scale !== 1) {
        if (circle.getAttribute('stroke-width')) {
            let lineWidth = parseInt(circle.getAttribute('stroke-width')) * scale
            if (lineWidth < 2) lineWidth = 2
            circle.setAttribute('stroke-width', String(lineWidth))
        }
    }
    groupStyle(circle, style) // 组样式补全
    const path = circle
    callback({ path, coords })
}

/* Method： circleToCoords
    * 将椭圆转变成坐标点
    * 参数：ellipse：svg椭圆数据；scale：缩放, numPoints：点数, translateX, translateY：左上点位置
    * 返回：组成svg的点信息（）
    */
export const ellipseToCoords = (ellipse, scale, numPoints, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 弧度 = 2*PI/360*角度
    const aRadian = 2 * Math.PI / numPoints // 角的弧度
    const cx = parseFloat(ellipse.getAttribute('cx')) * scale
    const cy = parseFloat(ellipse.getAttribute('cy')) * scale
    const rx = parseFloat(ellipse.getAttribute('rx')) * scale
    const ry = parseFloat(ellipse.getAttribute('ry')) * scale
    const getRange = range(0, numPoints + 1) // 多加一个点首末坐标相同封口
    let x1 = 0.0// 椭圆上坐标点x
    let y1 = 0.0// 椭圆上坐标点y
    // 椭圆周长上的点
    let coords = null
    // 椭圆公式(根据公式获得椭圆上点坐标)
    const points = getRange.map(function (i) {
        x1 = cx + rx * Math.cos(aRadian * i)
        y1 = cy + ry * Math.sin(aRadian * i)
        return [x1 + translateX, y1 + translateY]
    })
    points[numPoints] = points[0] // 椭圆周长上点封闭
    // 旋转计算
    if (rotate !== 0) {
        coords = points.map(function (p) {
            const x = p[0] - cp[0] // cp.x
            const y = p[1] - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else {
        coords = points
    }
    if (scale !== 1) {
        if (ellipse.getAttribute('stroke-width')) {
            let lineWidth = parseInt(ellipse.getAttribute('stroke-width')) * scale
            if (lineWidth < 2) lineWidth = 2
            ellipse.setAttribute('stroke-width', String(lineWidth))
        }
    }
    groupStyle(ellipse, style) // 组样式补全
    const path = ellipse
    callback({ path, coords })
}

/* Method： polylineToCoords
  * 将多边形线转变成坐标点
  * 参数：polyline：svg多边线数据；scale：缩放, translateX, translateY：左上点位置
  * 返回：组成svg的点信息（）
  */
export const polylineToCoords = (polyline, scale, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 获取多边形线的节点
    const pointStr = polyline.getAttribute('points')
    const pointsLs = pointStr.split(' ')
    const points = pointsLs.map(function (coord) {
        const coordStr = coord.split(',')
        return [parseFloat(coordStr[0]), parseFloat(coordStr[1])]
    })
    let coords = null
    if (rotate !== 0) {
        coords = points.map(function (p) {
            const x = (p[0] * scale + translateX) - cp[0] // cp.x
            const y = (p[1] * scale + translateY) - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
        // 没有旋转
    } else {
        coords = points.map(function (p) {
            return [p[0] * scale + translateX, p[1] * scale + translateY]
        })
    }
    groupStyle(polyline, style) // 组样式补全
    const path = polyline
    callback({ path, coords })
}

/* Method： polygonToCoords
  * 将多边形线转变成坐标点
  * 参数：polygon：svg多边形数据；scale：缩放, translateX, translateY：左上点位置
  * 返回：组成svg的点信息（）
  */
export const polygonToCoords = (polygon, scale, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 获取多边形线的节点
    const pointStr = polygon.getAttribute('points')
    const pointsLs = pointStr.split(' ')
    // 获取每个坐标点的值
    const points = pointsLs.map(function (coord) {
        const coordStr = coord.split(',')
        return [parseFloat(coordStr[0]), parseFloat(coordStr[1])]
    })
    let coords = null
    if (rotate !== 0) {
        coords = points.map((p) => {
            // 首先将坐标移动到原点（当前点+左上角位置）- 原点坐标
            const x = (p[0] * scale + translateX) - cp[0] // .x
            const y = (p[1] * scale + translateY) - cp[1] // .y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0]
            const fy = ry + cp[1]
            return [fx, fy]
        })
    } else { // 没有旋转
        coords = points.map(function (p) {
            return [p[0] * scale + translateX, p[1] * scale + translateY]
        })
    }
    if (coords.length > 0) {
        coords.push(coords[0])
        groupStyle(polygon, style) // 组样式补全
        const path = polygon
        callback({ path, coords })
    }
}

/* Method：rectToCoords
* 将矩形线转变成坐标点
* 参数：rect：svg矩形数据；scale：缩放, translateX, translateY：左上点位置
* 返回：组成svg的点信息（）
*/
export const rectToCoords = (rect, scale, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 获取多边形线的节点
    const x = parseFloat(rect.getAttribute('x')) // 左上角坐标x
    const y = parseFloat(rect.getAttribute('y')) // 左上角坐标y
    const w = parseFloat(rect.getAttribute('width')) // 矩形宽
    const h = parseFloat(rect.getAttribute('height')) // 矩形高
    // 保存矩形坐标数组
    let coords = null
    // 计算各个点的坐标
    const points = []
    points.push([x * scale + translateX, y * scale + translateY])
    points.push([(x + w) * scale + translateX, y * scale + translateY])
    points.push([(x + w) * scale + translateX, (y + h) * scale + translateY])
    points.push([x * scale + translateX, (y + h) * scale + translateY])
    points.push(points[0]) // 矩形上点封闭
    // 处理旋转
    if (rotate !== 0) {
        coords = points.map(function (p) {
            // 首先将坐标移动到原点（当前点+左上角位置）- 原点坐标
            const x = p[0] - cp[0] // .x
            const y = p[1] - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else { // 没有旋转
        coords = points
    }
    // 数据保存rect
    groupStyle(rect, style) // 组样式补全
    const path = rect
    callback({ path, coords })
}
/* Method：lineToCoords
    * 将线段转变成坐标点
    * 参数：line：svg线段数据；scale：缩放, translateX, translateY：左上点位置
    * 返回：组成svg的点信息（）
    */
export const lineToCoords = (line, scale, translateX, translateY, cp, rotate = 0, callback, style) => {
    // 获取多边形线的节点
    const x1 = parseFloat(line.getAttribute('x1')) // 左上角坐标x
    const y1 = parseFloat(line.getAttribute('y1')) // 左上角坐标y
    const x2 = parseFloat(line.getAttribute('x2')) // 矩形宽
    const y2 = parseFloat(line.getAttribute('y2')) // 矩形高
    // 保存线端点坐标数组
    let coords = null
    // 计算各个点的坐标
    const points = []
    points.push([x1 * scale + translateX, y1 * scale + translateY])
    points.push([x2 * scale + translateX, y2 * scale + translateY])
    // 处理旋转
    if (rotate !== 0) {
        coords = points.map(function (p) {
            // 首先将坐标移动到原点（当前点+左上角位置）- 原点坐标
            const x = p[0] - cp[0] // cp.x
            const y = p[1] - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else { // 没有旋转
        coords = points
    }
    // 数据保存
    groupStyle(line, style) // 组样式补全
    const path = line
    callback({ path, coords })
}
export const textToCoords = (txt, scale, translateX, translateY, cp, rotate = 0, callback) => {
    // 获取文字transform
    const txtMatrix = txt.getAttribute('transform')
    const s = txtMatrix.indexOf('(')
    const strArr = txtMatrix.substring(s + 1, txtMatrix.length - 1).split(' ')
    const iMatrix = strArr.map(function (m) {
        return parseFloat(m)
    })
    const len = iMatrix.length
    const x = iMatrix[len - 2]
    const y = iMatrix[len - 1]
    // 计算各个点的坐标
    let coords = null
    const points = []
    points.push([x * scale + translateX, y * scale + translateY])
    // 文字处理中，添加缩放和旋转因子在coords数组 [scale, 0-待定]
    if (rotate !== 0) {
        coords = points.map(function (p) {
            // 首先将坐标移动到原点（当前点+左上角位置）- 原点坐标
            const x = p[0] - cp[0] // cp.x
            const y = p[1] - cp[1] // cp.y
            const r = Math.sqrt((x) * (x) + (y) * (y))
            let rad = 0
            if (x >= 0) {
                rad = Math.asin(y / r)
            } else {
                rad = Math.PI - Math.asin(y / r)
            }
            if (r === 0) return [0, 0]
            // 进行旋转操作
            const rx = r * Math.cos(rad + rotate)
            const ry = r * Math.sin(rad + rotate)
            const fx = rx + cp[0] // cp.x
            const fy = ry + cp[1] // cp.y
            return [fx, fy]
        })
    } else { // 没有旋转
        coords = points
    }
    // // 数据保存
    const path = txt
    callback({ path, coords })
}

/* Method：parseItem
   * 分析SVG每一条的数据
   * 参数：itemData:svg每个元素数据, translateX：移动x方向值, translateY：移动y方向值, centerPoint:SVG中心点坐标， scale：缩放因子, rotate：旋转, numPoints:分段数量（path,圆和椭圆分段数量）
   * 返回：新生成的图形屏幕坐标
   */
export const parseItem = (itemData, translateX, translateY, centerPoint, scale = 1, rotate = 0, numPoints = 20, callback) => {
    const gFill = itemData.getAttribute('fill')
    const gStroke = itemData.getAttribute('stroke')
    const gStrokeWidth = itemData.getAttribute('stroke-width')
    let gStyle
    if (gFill || gStroke || gStrokeWidth) {
        gStyle = { fill: gFill, stroke: gStroke, 'stroke-width': gStrokeWidth }
    }
    // 按照类型再次分析
    for (let i = 0; i < itemData.childNodes.length; i++) {
        const tName = itemData.childNodes[i].tagName
        switch (tName) {
            case 'path': // 处理数据路径数据
                pathToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    numPoints, // NUM_POINTS 路径分成点数；不同类型不同数量  ?20
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'circle': // 处理圆形数据
                circleToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    numPoints, // NUM_POINTS 路径分成点数；圆18个点
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'ellipse': // 处理椭圆数据
                ellipseToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    numPoints, // NUM_POINTS 路径分成点数；圆18个点
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'polyline': // 处理多边形线数据
                polylineToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'polygon': // 处理多边形数据
                polygonToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'rect': // 处理矩形数据
                rectToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'line': // 处理线段数据
                lineToCoords(itemData.childNodes[i],
                    scale, // 缩放SCALE 1
                    translateX,
                    translateY,
                    centerPoint, rotate, (obj) => { callback(obj) }, gStyle)
                break
            case 'text': // 处理线段数据
                textToCoords(itemData.childNodes[i], scale, translateX, translateY, centerPoint, rotate, (obj) => { callback(obj) })
                break
            case 'g': // 处理组数据
                parseItem(itemData.childNodes[i], translateX, translateY, centerPoint, scale, rotate, numPoints, (obj) => { callback(obj) }, gStyle)
                break
        }
    }
    // 绘制完成后，将gStyle清空
    gStyle = null
}

// getTxtCPntAndWH 获得文字控制点2和文字块的宽高
// basePnt:控制点, fontSize：文字尺寸（不带PX后缀）, txt：文本内容
export const getTxtCPntAndWH = (basePnt, fontSize, txt) => {
    let txtSize = fontSize;
    let tail = null;
    // 如果txtSize长度大于2，验证是否带px后缀
    if (txtSize.length > 2) {
        tail = fontSize.substring(fontSize.length - 2);
    }
    // 如果文字尺寸带px
    if (tail && tail.toLowerCase() === "px") {
        txtSize = fontSize.substr(fontSize, fontSize.length - 2);
        if (!isNaN(txtSize) && parseInt(txtSize) > 0) {
            txtSize = parseInt(txtSize);
        } else {
            txtSize = 12;
        }
    } else {
        // 不带后缀，设置文字尺寸
        if (!isNaN(txtSize) && parseInt(txtSize) > 0) {
            txtSize = parseInt(txtSize);
        } else {
            txtSize = 12;
        }
    }
    // 将文本分解成数组，以便获取最长行文字数量
    const txtArr = txt.split(/[(\r\n)\r\n]+/);
    const numLine = txtArr.length; // 行数量
    let maxLen = 0;
    for (let i = 0; i < numLine; i++) {
        if (maxLen < txtArr[i].length) {
            maxLen = txtArr[i].length;
        }
    }
    // 字的尺寸 * 字数量 = 一行所占的像素数量
    const w = txtSize * maxLen;
    // 行的高度 * 行数量 / 2 (左下坐标是行高一半)
    const h = ((txtSize + txtSize * 0.5) * numLine) / 2;
    // 中心点（控制点1）
    const screenCoord = map.getPixelFromCoordinate(basePnt);
    const screenCoord2 = [screenCoord[0] + w, screenCoord[1] - h]; // 屏幕坐标左上角是原点
    const cp2 = map.getCoordinateFromPixel(screenCoord2); // 计算得到控制点2
    return { cp: [basePnt, cp2], boxWH: { w: w, h: h } };
}

// 休眠-sleep -- 本地方法，暂未使用
export const sleep = (ms) => {
    return new Promise(resolve => setTimeout(resolve, ms))
}

// 计算数组中所有值的最大和最小值（提出到imapBase.js中）
// 返回：方位盒 [minx, miny, maxx, maxy]
export const getMinMax = (geoCoord) => {
    const coordArray = geoCoord[0];
    const iNum = coordArray.length; // 边界坐标数组
    if (iNum === 0) return null;
    const mixArr = [coordArray[0][0], coordArray[0][1]]; // 坐标最小值
    const maxArr = [coordArray[0][0], coordArray[0][1]]; // 坐标最大值
    let currVal;
    for (let i = 1; i < iNum; i++) {
        currVal = coordArray[i];
        // 当前值的x小于最小值x
        if (currVal[0] < mixArr[0]) {
            mixArr[0] = currVal[0];
        }
        if (currVal[1] < mixArr[1]) {
            mixArr[1] = currVal[1];
        }
        // 当前值大于最大值
        if (currVal[0] > maxArr[0]) {
            maxArr[0] = currVal[0];
        }
        if (currVal[1] > maxArr[1]) {
            maxArr[1] = currVal[1];
        }
    }
    // 返回 [minx, miny, maxx, maxy] 范围盒
    return [mixArr[0], mixArr[1], maxArr[0], maxArr[1]];
};